Tworzenie Pandas DataFrame: Dogłębne spojrzenie na inicjalizację struktur danych

Witaj w świecie manipulacji danymi za pomocą Pythona! W sercu niemal każdego zadania analizy danych leży biblioteka Pandas, a jej kamieniem węgielnym jest DataFrame. Pomyśl o DataFrame jako o inteligentnej, potężnej i elastycznej wersji arkusza kalkulacyjnego lub tabeli bazy danych, żyjącej bezpośrednio w Twoim środowisku Pythona. Jest to podstawowe narzędzie do czyszczenia, transformowania, analizowania i wizualizowania danych. Ale zanim wykonasz którąkolwiek z tych operacji, musisz najpierw opanować sztukę tworzenia DataFrame. Sposób inicjalizacji tej fundamentalnej struktury danych może ustawić scenę dla całej Twojej analizy.

Ten obszerny przewodnik został zaprojektowany dla globalnej publiczności początkujących i praktykujących analityków danych, naukowców i inżynierów. Zbadamy najpopularniejsze i najpotężniejsze metody tworzenia Pandas DataFrames od podstaw. Niezależnie od tego, czy Twoje dane znajdują się w słowniku, liście, tablicy NumPy czy w innym formacie, ten artykuł dostarczy Ci wiedzy i praktycznych przykładów, aby inicjalizować DataFrames z pewnością i efektywnością. Zbudujmy nasze fundamenty.

Czym dokładnie jest Pandas DataFrame?

Zanim zaczniemy budować, wyjaśnijmy, co konstruujemy. Pandas DataFrame to dwuwymiarowa, zmienna rozmiarowo i potencjalnie heterogeniczna tabelaryczna struktura danych. Rozłóżmy to na czynniki pierwsze:

• Dwuwymiarowy: Posiada wiersze i kolumny, tak jak arkusz kalkulacyjny.
• Zmienny rozmiarowo: Możesz dodawać lub usuwać wiersze i kolumny po utworzeniu DataFrame.
• Heterogeniczny: Kolumny mogą zawierać różne typy danych. Na przykład jedna kolumna może zawierać liczby (całkowite lub zmiennoprzecinkowe), inna tekst (ciągi znaków), a trzecia daty lub wartości logiczne (Prawda/Fałsz).

DataFrame składa się z trzech głównych komponentów:

1. Dane: Rzeczywiste wartości przechowywane w strukturze, zorganizowane w wiersze i kolumny.
2. Indeks: Etykiety dla wierszy. Jeśli nie podasz indeksu, Pandas utworzy domyślny, zaczynając od 0. Indeks zapewnia potężny sposób dostępu do danych i ich wyrównywania.
3. Kolumny: Etykiety dla kolumn. Są one kluczowe dla dostępu do konkretnych serii danych w obrębie DataFrame.

Zrozumienie tej struktury jest kluczowe dla efektywnego tworzenia i manipulowania DataFrames.

Podstawy: Importowanie Pandas

Przede wszystkim. Aby używać Pandas, musisz zaimportować bibliotekę do swojego skryptu lub notatnika Pythona. Powszechnie przyjętą konwencją, stosowaną przez profesjonalistów na całym świecie, jest importowanie jej z aliasem pd. Ten prosty alias sprawia, że Twój kod jest bardziej czytelny i zwięzły.

import pandas as pd
import numpy as np # Często używany razem z Pandas, więc zaimportujemy go również.

Dzięki tej jednej linii odblokowałeś pełną moc biblioteki Pandas. Teraz przejdźmy do sedna tego przewodnika: tworzenia DataFrames.

Podstawowe metody tworzenia: Od prostych do złożonych

Konstruktor pd.DataFrame() jest niezwykle wszechstronny. Może przyjmować wiele różnych typów danych wejściowych. Teraz zbadamy najbardziej podstawowe metody, przechodząc od najczęściej używanych do bardziej specjalistycznych przypadków.

1. Tworzenie DataFrame ze słownika list lub tablic

Jest to prawdopodobnie najczęstsza i najbardziej intuicyjna metoda tworzenia DataFrame. Zaczynasz od słownika Pythona, gdzie klucze staną się nazwami kolumn, a wartości będą listami (lub tablicami NumPy lub seriami Pandas) zawierającymi dane dla każdej kolumny.

Jak to działa: Pandas mapuje każdy klucz słownika do nagłówka kolumny i każdą listę wartości do wierszy tej kolumny. Kluczowym wymogiem jest to, że wszystkie listy muszą mieć tę samą długość, ponieważ każda lista reprezentuje pełną kolumnę danych.

Przykład:

Utwórzmy DataFrame zawierający informacje o różnych miastach na świecie.

# Data organized by column city_data = { 'City': ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'], 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } # Create the DataFrame df_from_dict = pd.DataFrame(city_data) print(df_from_dict)

Wynik:

         City Country  Population_Millions  Is_Coastal
0       Tokyo   Japan                 37.3        True
1       Delhi   India                 32.0       False
2    Shanghai   China                 28.5        True
3   São Paulo  Brazil                 22.4       False
4      Mumbai   India                 20.9        True

Kluczowa wskazówka: Ta metoda jest idealna, gdy Twoje dane są naturalnie zorganizowane według cech lub kategorii. Jest czytelna, klarowna i bezpośrednio przekłada strukturę Twojego słownika na format tabelaryczny.

2. Tworzenie DataFrame z listy słowników

Alternatywną i równie potężną metodą jest użycie listy, gdzie każdy element jest słownikiem. W tej strukturze każdy słownik reprezentuje pojedynczy wiersz, a jego klucze reprezentują nazwy kolumn dla danych tego wiersza.

Jak to działa: Pandas iteruje po liście. Dla każdego słownika tworzy nowy wiersz. Klucze słownika są używane do określania kolumn. Ta metoda jest niezwykle elastyczna, ponieważ jeśli w słowniku brakuje klucza, Pandas automatycznie wypełni tę komórkę w odpowiednim wierszu wartością NaN (Not a Number), która jest standardowym znacznikiem brakujących danych w Pandas.

Przykład:

Przedstawmy te same dane miast, ale tym razem w formie listy rekordów.

# Data organized by row (record) records_data = [ {'City': 'Tokyo', 'Country': 'Japan', 'Population_Millions': 37.3, 'Is_Coastal': True}, {'City': 'Delhi', 'Country': 'India', 'Population_Millions': 32.0, 'Is_Coastal': False}, {'City': 'Shanghai', 'Country': 'China', 'Population_Millions': 28.5}, {'City': 'São Paulo', 'Country': 'Brazil', 'Population_Millions': 22.4, 'Is_Coastal': False}, {'City': 'Cairo', 'Country': 'Egypt', 'Timezone': 'EET'} # Note the different structure ] # Create the DataFrame df_from_list_of_dicts = pd.DataFrame(records_data) print(df_from_list_of_dicts)

Wynik:

         City Country  Population_Millions  Is_Coastal Timezone
0       Tokyo   Japan                 37.3        True      NaN
1       Delhi   India                 32.0       False      NaN
2    Shanghai   China                 28.5         NaN      NaN
3   São Paulo  Brazil                 22.4       False      NaN
4       Cairo   Egypt                  NaN         NaN      EET

Zauważ, jak Pandas elegancko poradził sobie z niespójnościami. Wartość 'Is_Coastal' dla Szanghaju to NaN, ponieważ brakowało jej w słowniku. Nowa kolumna 'Timezone' została utworzona dla Kairu, z wartością NaN dla wszystkich pozostałych miast. To czyni ją doskonałym wyborem do pracy z danymi półstrukturalnymi, takimi jak odpowiedzi JSON z API.

Kluczowa wskazówka: Użyj tej metody, gdy Twoje dane są serią rekordów lub obserwacji. Jest ona wytrzymała w obsłudze brakujących danych i różnic w strukturze rekordów.

3. Tworzenie DataFrame z tablicy NumPy

Dla tych, którzy pracują w obliczeniach naukowych, uczeniu maszynowym lub w jakiejkolwiek dziedzinie obejmującej intensywne operacje numeryczne, dane często pochodzą z tablic NumPy. Pandas jest zbudowany na NumPy, co sprawia, że integracja między nimi jest płynna i bardzo wydajna.

Jak to działa: Przekazujesz dwuwymiarową tablicę NumPy do konstruktora pd.DataFrame(). Domyślnie Pandas utworzy indeksy i kolumny oparte na liczbach całkowitych. Możesz jednak (i powinieneś) dostarczyć znaczące etykiety za pomocą parametrów index i columns.

Przykład:

Utwórzmy DataFrame z losowo wygenerowanej tablicy NumPy o wymiarach 5x4, reprezentującej odczyty czujników w czasie.

# Create a 5x4 NumPy array with random data data_np = np.random.rand(5, 4) # Define column and index labels columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D'] index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04']) # Create the DataFrame df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns) print(df_from_numpy)

Wynik (Twoje losowe liczby będą się różnić):

                           Sensor_A  Sensor_B  Sensor_C  Sensor_D
2023-10-27 10:00:00  0.123456  0.987654  0.555555  0.111111
2023-10-27 10:01:00  0.234567  0.876543  0.666666  0.222222
2023-10-27 10:02:00  0.345678  0.765432  0.777777  0.333333
2023-10-27 10:03:00  0.456789  0.654321  0.888888  0.444444
2023-10-27 10:04:00  0.567890  0.543210  0.999999  0.555555

W tym przykładzie wprowadziliśmy również potężną funkcję: użycie DatetimeIndex dla danych szeregów czasowych, co odblokowuje szeroki wachlarz możliwości analizy opartej na czasie w Pandas.

Kluczowa wskazówka: Jest to najbardziej efektywna pod względem pamięci metoda tworzenia DataFrame z jednorodnych danych numerycznych. Jest to standardowy wybór podczas interfejsowania z bibliotekami takimi jak NumPy, Scikit-learn lub TensorFlow.

4. Tworzenie DataFrame z listy list

Ta metoda jest koncepcyjnie podobna do tworzenia z tablicy NumPy, ale używa standardowych list Pythona. Jest to prosty sposób na konwersję danych tabelarycznych przechowywanych w zagnieżdżonym formacie listy.

Jak to działa: Dostarczasz listę, gdzie każda wewnętrzna lista reprezentuje wiersz danych. Podobnie jak w przypadku tablic NumPy, zdecydowanie zaleca się określenie nazw kolumn za pomocą parametru columns dla jasności.

Przykład:

# Data as a list of rows product_data = [ ['P001', 'Laptop', 1200.00, 'Electronics'], ['P002', 'Mouse', 25.50, 'Electronics'], ['P003', 'Desk Chair', 150.75, 'Furniture'], ['P004', 'Keyboard', 75.00, 'Electronics'] ] # Define column names column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category'] # Create the DataFrame df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names) print(df_from_list_of_lists)

Wynik:

  ProductID ProductName  Price_USD     Category
0      P001      Laptop    1200.00  Electronics
1      P002       Mouse      25.50  Electronics
2      P003  Desk Chair     150.75    Furniture
3      P004    Keyboard      75.00  Electronics

Kluczowa wskazówka: Jest to prosta i skuteczna metoda, gdy Twoje dane są już ustrukturyzowane jako lista wierszy, na przykład podczas odczytu z formatu pliku, który nie ma nagłówków.

Zaawansowana inicjalizacja: Dostosowywanie DataFrame

Oprócz dostarczania surowych danych, konstruktor pd.DataFrame() oferuje kilka parametrów do kontrolowania struktury i właściwości nowego DataFrame od momentu jego utworzenia.

Określanie indeksu

Widzieliśmy już w akcji parametr `index`. Indeks jest kluczową częścią DataFrame, dostarczając etykiet dla wierszy, które są używane do szybkich wyszukiwań, wyrównywania danych i wielu innych. Chociaż Pandas udostępnia domyślny indeks numeryczny (0, 1, 2, ...), ustawienie znaczącego indeksu może znacznie ułatwić pracę z danymi.

Przykład: Użyjmy ponownie naszego przykładu słownika list, ale ustawmy kolumnę `City` jako indeks podczas tworzenia.

city_data = { 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } city_names = ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'] # Create the DataFrame with a custom index df_with_index = pd.DataFrame(city_data, index=city_names) print(df_with_index)

Wynik:

          Country  Population_Millions  Is_Coastal
Tokyo       Japan                 37.3        True
Delhi       India                 32.0       False
Shanghai    China                 28.5        True
São Paulo  Brazil                 22.4       False
Mumbai      India                 20.9        True

Teraz możesz uzyskać dostęp do danych wierszy, używając tych znaczących etykiet, na przykład za pomocą df_with_index.loc['Tokyo'].

Kontrolowanie typów danych (`dtype`)

Pandas jest dość dobry w wnioskowaniu typów danych (np. rozpoznawaniu liczb, tekstu i wartości logicznych). Czasami jednak trzeba wymusić konkretny typ danych dla kolumny, aby zapewnić efektywność pamięci lub umożliwić określone operacje. Parametr `dtype` daje Ci tę kontrolę.

Przykład: Wyobraźmy sobie, że mamy identyfikatory produktów, które wyglądają jak liczby, ale powinny być traktowane jako tekst (ciągi znaków).

data = { 'ProductID': [101, 102, 103], 'Stock': [50, 75, 0] } # Create DataFrame while specifying a dtype for 'ProductID' df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'}) print(df_types.dtypes)

Wynik:

ProductID    object
Stock         int32
dtype: object

Zauważ, że `str` w Pandas jest reprezentowany jako `object`. Jawne ustawienie `dtype` zapobiega traktowaniu `ProductID` przez Pandas jako liczby, co mogłoby prowadzić do niepoprawnych obliczeń lub problemów z sortowaniem w przyszłości. Używanie bardziej specyficznych typów całkowitych, takich jak `int32` zamiast domyślnego `int64`, może również zaoszczędzić znaczną ilość pamięci przy dużych zbiorach danych.

Praktyczne scenariusze i najlepsze praktyki

Wybór odpowiedniej metody tworzenia zależy od oryginalnego formatu Twoich danych. Oto prosty przewodnik decyzyjny:

• Czy Twoje dane są w kolumnach (np. jedna lista na cechę)? Użyj słownika list. Pasuje to naturalnie.
• Czy Twoje dane to seria rekordów (np. z API JSON)? Użyj listy słowników. Doskonale radzi sobie z brakującymi lub dodatkowymi polami w rekordach.
• Czy Twoje dane są numeryczne i w siatce (np. z obliczeń naukowych)? Użyj tablicy NumPy. Jest to najbardziej wydajna opcja dla tego przypadku użycia.
• Czy Twoje dane są w prostym formacie tabelarycznym wiersz po wierszu bez nagłówków? Użyj listy list i dostarcz nazwy kolumn oddzielnie.

Częste pułapki, których należy unikać

1. Nierówne długości w słowniku list: To częsty błąd. Podczas tworzenia DataFrame ze słownika list, każda lista musi mieć dokładnie taką samą liczbę elementów. W przeciwnym razie Pandas zgłosi `ValueError`. Zawsze upewnij się, że dane w kolumnach mają równą długość przed utworzeniem.
2. Ignorowanie indeksu: Opieranie się na domyślnym indeksie bazującym na 0 jest w wielu przypadkach w porządku, ale jeśli Twoje dane mają naturalny identyfikator (taki jak ID Produktu, ID Użytkownika lub konkretny znacznik czasu), ustawienie go jako indeksu od początku może uprościć Twój kod później.
3. Zapominanie o typach danych: Pozwalanie Pandas na wnioskowanie typów działa przez większość czasu, ale w przypadku dużych zbiorów danych lub kolumn z mieszanymi typami, wydajność może ucierpieć. Bądź proaktywny w ustawianiu `dtype` dla kolumn, które mają być traktowane jako kategorie, ciągi znaków lub określone typy numeryczne, aby zaoszczędzić pamięć i zapobiec błędom.

Poza inicjalizacją: Tworzenie DataFrames z plików

Chociaż ten przewodnik koncentruje się na tworzeniu DataFrames z obiektów Pythona w pamięci, kluczowe jest, aby wiedzieć, że w większości scenariuszy w świecie rzeczywistym Twoje dane będą pochodzić z zewnętrznego pliku. Pandas zapewnia zestaw wysoce zoptymalizowanych funkcji odczytu do tego celu, w tym:

• pd.read_csv(): Dla plików wartości oddzielonych przecinkami, jest to siła robocza importu danych.
• pd.read_excel(): Do odczytu danych z arkuszy kalkulacyjnych Microsoft Excel.
• pd.read_json(): Do odczytu danych z plików lub ciągów JSON.
• pd.read_sql(): Do odczytu wyników zapytania do bazy danych bezpośrednio do DataFrame.
• pd.read_parquet(): Do odczytu z wydajnego, kolumnowego formatu pliku Parquet.

Te funkcje są kolejnym logicznym krokiem w Twojej podróży z Pandas. Opanowanie ich pozwoli Ci na pobieranie danych praktycznie z dowolnego źródła do potężnej struktury DataFrame.

Podsumowanie: Twoje fundamenty dla mistrzostwa danych

Pandas DataFrame to centralna struktura danych dla każdej poważnej pracy z danymi w Pythonie. Jak widzieliśmy, Pandas oferuje elastyczny i intuicyjny zestaw narzędzi do inicjalizacji tych struktur z szerokiej gamy formatów. Rozumiejąc, jak utworzyć DataFrame ze słowników, list i tablic NumPy, zbudowałeś solidne fundamenty dla swoich projektów analizy danych.

Kluczem jest wybranie metody, która najlepiej pasuje do oryginalnej struktury Twoich danych. To nie tylko sprawia, że Twój kod jest czystszy i bardziej czytelny, ale także bardziej wydajny. Stąd jesteś gotowy, aby przejść do ekscytujących zadań czyszczenia, eksploracji, transformacji i wizualizacji danych. Udanej pracy!